single_step_integrator Derived Type

private subroutine oi_append_to_buffer(this, x, y, err)

Appends the supplied solution point to the internal solution buffer.

Arguments

subroutine attempt_single_step(this, sys, h, x, y, f, yn, fn, yerr, k) Prototype

Attempts an integration step for a single-step integrator.

Arguments

private subroutine oi_clear_buffer(this)

Clears the contents of the buffer.

Arguments

private pure function oi_estimate_error(this, y, yest, yerr) result(rst)

Computes the norm of the scaled error estimate. A value less than one indicates a successful step. A value greater than one suggests that the results do not meet the requested tolerances.

Arguments

Return Value real(kind=real64)

The norm of the scaled error.

private pure subroutine oi_initial_step(this, sys, xo, xf, yo, fo, h)

Computes an estimate of an initial step size.

Arguments

private function oi_next_step(this, e, eold, h, x, err) result(rst)

Estimates the next step size based upon the current and previous error estimates.

Arguments

Return Value real(kind=real64)

The new step size estimate.

private pure function oi_get_abs_tol(this) result(rst)

Gets the absolute error tolerance.

Arguments

Return Value real(kind=real64)

The tolerance value.

private pure function oi_get_allow_overshoot(this) result(rst)

Gets a value determining if the solver is allowed to overshoot the final value in the integration range.

Arguments

Return Value logical

True if the solver can overshoot, and then interpolate to achieve the required final value; else, false thereby indicating the solver cannot overshoot.

pure function get_single_step_logical_parameter(this) result(rst) Prototype

Returns a logical parameter from a single_step_integrator object.

Arguments

Return Value logical

The parameter.

private pure function oi_get_max_step(this) result(rst)

Gets the magnitude of the maximum allowed step size.

Arguments

Return Value real(kind=real64)

The step size limit.

private pure function oi_get_min_step(this) result(rst)

Gets the magnitude of the minimum allowed step size.

Arguments

Return Value real(kind=real64)

The step size limit.

pure function ode_integer_inquiry(this) result(rst) Prototype

Returns an integer value from the ode_integrator object.

Arguments

Return Value integer(kind=int32)

The requested value.

private pure function oi_get_abs_tol(this) result(rst)

Gets the absolute error tolerance.

Arguments

Return Value real(kind=real64)

The tolerance value.

private pure function oi_get_solution(this) result(rst)

Returns the solution computed by the integrator stored as a matrix with the first column containing the values of the independent variable at which the solution was computed. The remaining columns contain the solutions for each of the integrated equations in the order in which they appear in the source routine. Notice, the solve routine must be called before this routine.

Arguments

Return Value real(kind=real64), allocatable, dimension(:,:)

The resulting solution matrix.

pure function single_step_integer_inquiry(this) result(rst) Prototype

Gets an integer from the integrator.

Arguments

Return Value integer(kind=int32)

The integer value.

private pure function oi_get_step_limit(this) result(rst)

Gets the limit on the number of integration steps that may be taken before the solver terminates.

Arguments

Return Value integer(kind=int32)

The step limit.

private pure function oi_get_control_parameter(this) result(rst)

Gets the step size control parameter $\beta$ used for PI control of the step size. A value of 0 provides a default step size controller (non-PI); however, a nonzero value of $\beta$ provides PI control that improves stability, but comes with a potential for efficiency loss. A good estimate for a starting point for this parameter is $\beta = \frac{0.4}{k}$ where $k$ is the order of the integrator.

The PI controller for step size is defined as follows. $$h_{n+1} = f_{s} h_{n} e_{n}^{-\alpha} e_{n-1}^{\beta}$$

Arguments

Return Value real(kind=real64)

The control parameter.

private pure function oi_get_safety_factor(this) result(rst)

Gets the safety factor (step size multiplier) used to provide a measure of control to the step size estimate such that $h_{new} = f_{s} h$, where $f_{s}$ is this safety factor.

Arguments

Return Value real(kind=real64)

The safety factor.

subroutine single_step_interpolate(this, x, xn, yn, fn, xn1, yn1, fn1, y) Prototype

Provides a routine for interpolation.

Arguments

subroutine single_step_post_step_routine(this, sys, dense, x, xn, y, yn, f, fn, k) Prototype

Provides a routine for performing any actions, such as setting up interpolation, after successful completion of a step.

Arguments

subroutine single_step_pre_step_routine(this, prevs, sys, h, x, y, f, err) Prototype

Provides a routine for performing any actions, such as setting up Jacobian calculations.

Arguments

private subroutine oi_set_abs_tol(this, x)

Sets the absolute error tolerance.

Arguments

private subroutine oi_set_allow_overshoot(this, x)

Sets a value determining if the solver is allowed to overshoot the final value in the integration range.

Arguments

private subroutine oi_set_max_step(this, x)

Sets the magnitude of the maximum allowed step size.

Arguments

private subroutine oi_set_min_step(this, x)

Sets the magnitude of the minimum allowed step size.

Arguments

private subroutine oi_set_abs_tol(this, x)

Sets the absolute error tolerance.

Arguments

private subroutine oi_set_step_limit(this, x)

Sets the limit on the number of integration steps that may be taken before the solver terminates.

Arguments

private subroutine oi_set_control_parameter(this, x)

Sets the step size control parameter $\beta$ used for PI control of the step size. A value of 0 provides a default step size controller (non-PI); however, a nonzero value of $\beta$ provides PI control that improves stability, but comes with a potential for efficiency loss. A good estimate for a starting point for this parameter is $\beta = \frac{0.4}{k}$ where $k$ is the order of the integrator.

The PI controller for step size is defined as follows. $$h_{n+1} = f_{s} h_{n} e_{n}^{-\alpha} e_{n-1}^{\beta}$$

Arguments

private subroutine oi_set_safety_factor(this, x)

Sets the safety factor (step size multiplier) used to provide a measure of control to the step size estimate such that $h_{new} = f_{s} h$, where $f_{s}$ is this safety factor.

Arguments

private subroutine ssi_ode_solver(this, sys, x, iv, err)

Solves the supplied system of ODE's.

Arguments